/**
 * Software License, Version 1.0
 * 
 * Copyright 2008 The Trustees of Indiana University.  All rights reserved.
 * 
 *
 *Redistribution and use in source and binary forms, with or without 
 *modification, are permitted provided that the following conditions are met:
 *
 *1) All redistributions of source code must retain the above copyright notice,
 * the list of authors in the original source code, this list of conditions and
 * the disclaimer listed in this license;
 *2) All redistributions in binary form must reproduce the above copyright 
 * notice, this list of conditions and the disclaimer listed in this license in
 * the documentation and/or other materials provided with the distribution;
 *3) Any documentation included with all redistributions must include the 
 * following acknowledgment:
 *
 *"This product includes software developed by the Community Grids Lab. For 
 * further information contact the Community Grids Lab at 
 * http://communitygrids.iu.edu/."
 *
 * Alternatively, this acknowledgment may appear in the software itself, and 
 * wherever such third-party acknowledgments normally appear.
 * 
 *4) The name Indiana University or Community Grids Lab or Granules, 
 * shall not be used to endorse or promote products derived from this software 
 * without prior written permission from Indiana University.  For written 
 * permission, please contact the Advanced Research and Technology Institute 
 * ("ARTI") at 351 West 10th Street, Indianapolis, Indiana 46202.
 *5) Products derived from this software may not be called Granules, 
 * nor may Indiana University or Community Grids Lab or Granules appear
 * in their name, without prior written permission of ARTI.
 * 
 *
 * Indiana University provides no reassurances that the source code provided 
 * does not infringe the patent or any other intellectual property rights of 
 * any other entity.  Indiana University disclaims any liability to any 
 * recipient for claims brought by any other entity based on infringement of 
 * intellectual property rights or otherwise.  
 *
 * LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH NO 
 * WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES
 * NO WARRANTIES AND MAKES NO REPRESENTATION THAT SOFTWARE IS FREE OF 
 * INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS. 
 * INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM "BUGS", 
 * "VIRUSES", "TROJAN HORSES", "TRAP DOORS", "WORMS", OR OTHER HARMFUL CODE.  
 * LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR 
 * ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION 
 * GENERATED USING SOFTWARE.
 */
package cgl.granules.exchange;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import cgl.granules.scheduler.TaskLifecycleMetrics;

public class TaskLifecycleMetricsReader implements TaskLifecycleMetrics {
    private long arrivalTime, cpuBoundTime, completionTime, startTime,
            timeResidentInMemory;
    private int numberOfIterationsSoFar, executionStatus;


    protected TaskLifecycleMetricsReader(byte[] marshalledBytes)
        throws IOException {
        ByteArrayInputStream baInputStream =
            new ByteArrayInputStream(marshalledBytes);
        DataInputStream din =
            new DataInputStream(new BufferedInputStream(baInputStream));

        arrivalTime = din.readLong();
        cpuBoundTime = din.readLong();
        completionTime = din.readLong();
        startTime = din.readLong();
        timeResidentInMemory = din.readLong();

        numberOfIterationsSoFar = din.readInt();
        executionStatus = din.readInt();
    }


    @Override
    public long getArrivalTime() {
        return arrivalTime;
    }


    @Override
    public long getCPUBoundTime() {
        return cpuBoundTime;
    }


    @Override
    public long getCompletionTime() {
        return completionTime;
    }


    @Override
    public int getNumberofIterationsSoFar() {
        return numberOfIterationsSoFar;
    }


    @Override
    public long getStartTime() {
        return startTime;
    }


    @Override
    public long getTimeResidentInMemory() {
        return timeResidentInMemory;
    }


    @Override
    public int getExecutionStatus() {
        return executionStatus;
    }


    @Override
    public byte[] getBytes() throws IOException {
        byte[] marshalledBytes = null;
        ByteArrayOutputStream baOutputStream = new ByteArrayOutputStream();
        DataOutputStream dout =
            new DataOutputStream(new BufferedOutputStream(baOutputStream));

        dout.writeLong(arrivalTime);
        dout.writeLong(cpuBoundTime);
        dout.writeLong(completionTime);
        dout.writeLong(startTime);
        dout.writeLong(timeResidentInMemory);

        dout.writeInt((int) numberOfIterationsSoFar);
        dout.writeInt(executionStatus);

        dout.flush();
        marshalledBytes = baOutputStream.toByteArray();
        return marshalledBytes;
    }


    @Override
    public String toString() {
        String stringRepresentation = "Execution Status=";
        switch (executionStatus) {
        case COMPLETE:
            stringRepresentation += "(COMPLETE) ";
            break;
        case EXECUTING:
            stringRepresentation += "(Executing) ";
            break;
        case WAITING_FOR_DATA:
            stringRepresentation += "(Waiting For Data) ";
            break;
        case QUEUED_FOR_EXECUTION:
            stringRepresentation += "(Queued For Execution) ";
            break;
        default:
            stringRepresentation += ("(Unknown = " + executionStatus + " ");
            break;
        }

        stringRepresentation +=
            " Arrival Time=" + arrivalTime + ", Start Time =" + startTime
                + ", CPU Bound Time = " + cpuBoundTime + " nanoSecs";

        if (numberOfIterationsSoFar > 1) {
            stringRepresentation +=
                (", Number Of Iterations =" + numberOfIterationsSoFar);
        }

        if (executionStatus == COMPLETE) {
            stringRepresentation += (", Completion Time =" + completionTime);
        }
        return stringRepresentation;
    }
}
